/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import type { Task_management_v1_Config } from '../models/Task_management_v1_Config';
import { request as __request, checkJsonSchema as __checkJsonSchema } from '../../core/request';
const schemas = require("../schema").default;

export class TestPlanManagementService {

    /**
     * Your GET endpoint
     * 获取指定产品版本下所有方案的基本信息
     * @returns any OK
     * @throws ApiError
     */
    public static async getPlans({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 所属产品版本ID
             */
            productVId: number,
            /**
             * 是否用于创建任务，可取值：
             * 0-否，1-是
             */
            forTask: number,
            /**
             * 分页查询的页数
             * 1）不传该参数，查询内容不分页
             * 2）传大于等于1的整数时，分页查询
             */
            pageNum?: number,
            /**
             * 分页查询的每页数据条数，取值范围 1-100。默认提取20条
             */
            pageDataCount?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 总记录数
         */
        totalDataCount: number,
        /**
         * 基础信息方案列表
         */
        plans: Array<{
            /**
             * 方案ID
             */
            id: number,
            /**
             * 方案名称
             */
            name: string,
            /**
             * 测试类型，可取值：
             * api - API测试
             * ui - UI测试
             * performance - 性能测试
             */
            type: string,
            /**
             * 用例数量
             */
            caseNumber: string,
            /**
             * 创建者名称
             */
            creatorName: string,
            /**
             * 创建时间
             */
            createTime: string,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/planmanager/v1/getPlans`,
            body: requestBody,
        });

        __checkJsonSchema("getPlans", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 获取指定方案的详细信息
     * @returns any OK
     * @throws ApiError
     */
    public static async getPlanDetail({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 方案ID
         */
        planId: number,
        /**
         * 方案名称
         */
        name: string,
        /**
         * 测试类型，可取值：
         * api - API测试
         * ui - UI测试
         * performance - 性能测试
         */
        type: string,
        /**
         * 用例数量
         */
        caseNumber: string,
        /**
         * 创建者名称
         */
        creatorName: string,
        /**
         * 创建时间
         */
        createTime: string,
        /**
         * 是否允许执行，可取值：
         * 0-否
         * 1-是
         */
        status: number,
        /**
         * 方案描述
         */
        description: string,
        /**
         * 目标配置
         * Config数据结构见“获取方案信息”
         */
        targetConfig: Array<Task_management_v1_Config>,
        /**
         * 环境配置
         */
        envConfig: Array<Task_management_v1_Config>,
        /**
         * 压力配置
         */
        stressConfig?: Array<Task_management_v1_Config>,
        /**
         * 自定义配置
         */
        selfConfig?: Array<Task_management_v1_Config>,
        /**
         * 用例树信息，包含与当前方案关系
         */
        cases: Array<{
            /**
             * 需求/用例ID
             */
            id: number,
            /**
             * 需求/用例名称
             */
            name: string,
            /**
             * 结点类型，可取值：
             * 1-需求项，2-用例项，3-无需求项
             */
            type: number,
            /**
             * 用例信息， 仅当type=2时有值
             */
            case?: Array<{
                /**
                 * 方案内用例的特定ID
                 */
                planCaseId: number,
                /**
                 * 是否可用，可取值：
                 * 0-否
                 * 1-是
                 */
                status: number,
                /**
                 * 用例包含的数据集条数
                 */
                dataSum: number,
                /**
                 * 测试结果评价策略，可取值：
                 * allsuccess - 全部成功才成功
                 * onesuccess - 成功一条就成功
                 * successrate - 成功率
                 */
                evaluateMethod: string,
                /**
                 * 成功率，当evaluateMethod=successrate时此项有值
                 */
                successRate?: number,
            }>,
            /**
             * 子节点列表，当type=1或3时有值
             */
            children?: Array<any>,
        }>,
        /**
         * 有运行权限的用户信息，包含与当前方案关系
         */
        runners: Array<{
            /**
             * 用户ID
             */
            id: number,
            /**
             * 用户名称
             */
            name: string,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/planmanager/v1/getPlanDetail`,
            body: requestBody,
        });

        __checkJsonSchema("getPlanDetail", schemas, result);
        return result.body;
    }

    /**
     * 将方案的状态在运行/禁止运行之间切换
     * @returns any Example response
     * @throws ApiError
     */
    public static async forbidPlan({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 是否禁止运行方案，可取值：
             * 0-否，1-是
             */
            forbidden: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/planmanager/v1/forbidPlan`,
            body: requestBody,
        });

        __checkJsonSchema("forbidPlan", schemas, result);
        return result.body;
    }

    /**
     * 对指定类别的方案配置数据进行替换
     * @returns any Example response
     * @throws ApiError
     */
    public static async changePlanConfig({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 配置的类别，可取值：
             * target – 目标配置
             * env – 环境配置
             * stress – 压力配置
             * self – 自定义配置
             */
            configType: string,
            /**
             * 目标配置
             */
            config: Array<Task_management_v1_Config>,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/planmanager/v1/changePlanConfig`,
            body: requestBody,
        });

        __checkJsonSchema("changePlanConfig", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 修改方案的描述内容
     * @returns any Example response
     * @throws ApiError
     */
    public static async changePlanDescription({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 方案的描述内容
             */
            description: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/planmanager/v1/changePlanDescription`,
            body: requestBody,
        });

        __checkJsonSchema("changePlanDescription", schemas, result);
        return result.body;
    }

    /**
     * 删除指定方案
     * @returns any Example response
     * @throws ApiError
     */
    public static async deletePlan({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'DELETE',
            path: `/planmanager/v1/deletePlan`,
            body: requestBody,
        });

        __checkJsonSchema("deletePlan", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 列举运行人员
     * @returns any OK
     * @throws ApiError
     */
    public static async getRunners({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 运行人员列表
         */
        runners: Array<{
            /**
             * 用户ID
             */
            id: number,
            /**
             * 用户名称
             */
            name: string,
            /**
             * 用户是否已被授权运行当前方案，可取值：0-否，1-是
             */
            inPlan?: number,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/planmanager/v1/listRunners`,
            body: requestBody,
        });

        __checkJsonSchema("getRunners", schemas, result);
        return result.body;
    }

    /**
     * 将选中的运行人员添加到当前方案中
     * @returns any Example response
     * @throws ApiError
     */
    public static async saveRunners({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 方案需要包含的运行人员信息
             */
            runner: Array<{
                /**
                 * 用户ID
                 */
                id: number,
            }>,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/planmanager/v1/editRunners`,
            body: requestBody,
        });

        __checkJsonSchema("saveRunners", schemas, result);
        return result.body;
    }

    /**
     * 修改用例的评价策略
     * @returns any Example response
     * @throws ApiError
     */
    public static async changeCasePolicy({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 用例ID
             */
            caseId: number,
            /**
             * 成功率，当evaluateMethod=successrate时此项有值
             */
            successRate?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/planmanager/v1/changeCasePolicy`,
            body: requestBody,
        });

        __checkJsonSchema("changeCasePolicy", schemas, result);
        return result.body;
    }

}